class PathFinder:
def __init__(self, hut_df, trail_df, trail_street_df, G_trail, G_street):
self.hut_df = hut_df
self.trail_df = trail_df
self.trail_street_df = trail_street_df
self.G_trail = G_trail
self.G_street = G_street
self.cities_centroid = self.load_centroid_in_graph_common_city()
def generate_route_trail_hut(self, hut_name, starting_city='Trento', return_path=False):
hut_row = self.hut_df.loc[self.hut_df['name'] == hut_name]
hut_in_graph = hut_row.closest_point_to_graph_id.values[0]
distance_hut_graph = hut_row.distance_graph.values[0]
self.print_info(hut_row, False)
trail_hut_street = self.trail_df.loc[ self.trail_df.src_node == hut_in_graph]
route_trail = list(reversed([int(i) for i in trail_hut_street.raw_route.values[0].split(",")]))
self.__print_route_stats(route_trail)
trail = trail_hut_street.geometry.values[0]
point_street = self.trail_street_df.loc[self.trail_street_df.hut == hut_name].geometry.values[0]
street_point_id = self.trail_street_df.loc[self.trail_street_df.hut == hut_name].street_graph_id.values[0]
street_route = ox.shortest_path(
self.G_street,
street_point_id,
self.cities_centroid[starting_city],
weight='travel_time'
)
edge_lengths = ox.utils_graph.get_route_edge_attributes(self.G_street, street_route, 'length')
edge_times = ox.utils_graph.get_route_edge_attributes(self.G_street, street_route, 'travel_time')
print('Street info:'); print(f"The route is long {round(sum(edge_lengths)/1000)}km")
print(f"The route takes {str(datetime.timedelta(seconds=sum(edge_times)))}"); print(f"{'-'*100}\n")
map = self.generate_map(street_route, hut_row, trail_hut_street, point_street, '')
return (map, self.route_nodes_to_line_networkx(street_route)) if return_path else map
def generate_map(self, route, hut, trail, street, detail):
dolomities_group = hut.dolomities.values[0]
feature_layers = dict(
dolomiti_area = FeatureGroup(name = 'Area Dolomiti'),
alpine_trail = FeatureGroup(name = 'Alpine trail'),
street_trail = FeatureGroup(name = 'Street-Trail joint'),
dolomities_group = FeatureGroup(name = f"Group of dolomities: {dolomities_group}")
)
# street
route_map = ox.plot_route_folium(self.G_street, route, tiles='OpenStreetMap')
# joint point
closest_point = folium.CircleMarker(
location= [list(reversed(i)) for i in list(street.coords)][0],
radius=8, color="green",
weight=4, fill=True, fill_color="green",
).add_to(feature_layers['street_trail'])
# dolomiti geo
dolomiti_geo_ = GeoJson(
data=dolomiti_df.loc[dolomiti_df['name']==hut.dolomities.values[0]],
style_function = styles.style_dolomiti,
tooltip=GeoJsonTooltip(fields=['name', 'url_info', 'area'])
).add_to(feature_layers['dolomiti_area'])
# trail
trail = PolyLine(
locations = [list(reversed(i)) for i in list(trail.geometry.values[0].coords)],
tooltip = self.custom_info(trail),
popup = self.custom_info(trail),
color='darkred', weight=3,
).add_to(feature_layers['alpine_trail'])
# huts
color = styles.c_colors[unique_dolomities_group.index(dolomities_group)]
marker = Marker(
location = [list(reversed(i)) for i in list(hut.geometry.values[0].coords)][0],
tooltip = self.custom_info(hut),
popup = self.custom_info(hut),
icon = Icon(color = color)
).add_to(feature_layers["dolomities_group"])
return utils.add_map_infos(feature_layers, route_map, collapsed_legend=True, reverse_order=False)
def load_centroid_in_graph_common_city(self) -> dict:
"return the nodes in the graph"
Trento = (11.121597, 46.065489)
Bolzano = (11.346474, 46.492602)
return dict(
Bolzano = ox.nearest_nodes(self.G_street, Bolzano[0], Bolzano[1]),
Trento = ox.nearest_nodes(self.G_street, Trento[0], Trento[1])
)
def print_info(self, hut_row, title=True):
if not title:
print(f"{'-' * 100}")
print('Hut info:');
print(self.custom_info(hut_row, '\n'))
print(f"{'-' * 100}")
def __print_route_stats(self, route):
print('Trail info:')
route_grades = ox.utils_graph.get_route_edge_attributes(self.G_trail, route, "grade_abs")
edge_times = ox.utils_graph.get_route_edge_attributes(self.G_trail, route, 'travel_time')
route_rises = ox.utils_graph.get_route_edge_attributes(self.G_trail, route, "rise")
route_lengths = ox.utils_graph.get_route_edge_attributes(self.G_trail, route, "length")
ascent = np.sum([rise for rise in route_rises if rise >= 0])
descent = np.sum([rise for rise in route_rises if rise < 0])
print(f"Estimated time: {str(datetime.timedelta(seconds=sum(edge_times)))} hours")
print(f"The average grade is {round(np.mean(route_grades) * 100)}% and the max is {round(np.max(route_grades) * 100)}%")
print(f"Total elevation change is {round(np.sum(route_rises))} meters: {round(ascent)} meter ascent and {round(abs(descent))} meter descent")
print(f"Total trip distance: {round(np.sum(route_lengths))} meters")
print(f"{'-' * 100}")
def custom_info(self, slice_df, join_type='<br/>'):
i = slice_df.to_dict(orient='list')
i = [f"{k.capitalize()}: {v[0]}" for k,v in i.items() if v[0] and k != 'geometry' and k != 'raw_route']
return join_type.join(i)
def get_trento_bz_raw_coordinates(self):
trento = (
self.G_street.nodes[self.cities_centroid['Trento']]['x'],
self.G_street.nodes[self.cities_centroid['Trento']]['y'],
)
bz = (
self.G_street.nodes[self.cities_centroid['Bolzano']]['x'],
self.G_street.nodes[self.cities_centroid['Bolzano']]['y'],
)
return dict(
Trento = Point(trento),
Bolzano = Point(bz),
)
def route_nodes_to_line_networkx(self, route):
points = []
for idnode in route:
lon = self.G_street.nodes[idnode]['x']
lat = self.G_street.nodes[idnode]['y']
point = Point(lon,lat)
points.append(point)
nodes = dict(
src_node = [route[0]],
tgt_node = [route[-1]]
)
return gpd.GeoDataFrame(nodes, geometry=[LineString(points)], crs="epsg:4326")
osm_rifugi['name'] = osm_rifugi['name'].apply(lambda x: x.replace('è','e').replace('ü', 'u').replace('ö', 'o'))
sentieri_huts_streets['hut'] = sentieri_huts_streets['hut'].apply(lambda x: x.replace('è','e').replace('ü', 'u').replace('ö', 'o'))
point_trail_street['hut'] = point_trail_street['hut'].apply(lambda x: x.replace('è','e').replace('ü', 'u').replace('ö', 'o'))
app = PathFinder(osm_rifugi, sentieri_huts_streets, point_trail_street, G_trail, G_street)
